home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / bison / yacc.c < prev   
Encoding:
C/C++ Source or Header  |  2006-04-25  |  38.2 KB  |  1,448 lines
  1. m4_divert(-1)                                                       -*- C -*-
  2.  
  3. # Yacc compatible skeleton for Bison
  4.  
  5. # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005
  6. # Free Software Foundation, Inc.
  7.  
  8. # This program is free software; you can redistribute it and/or modify
  9. # it under the terms of the GNU General Public License as published by
  10. # the Free Software Foundation; either version 2 of the License, or
  11. # (at your option) any later version.
  12.  
  13. # This program is distributed in the hope that it will be useful,
  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. # GNU General Public License for more details.
  17.  
  18. # You should have received a copy of the GNU General Public License
  19. # along with this program; if not, write to the Free Software
  20. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21. # 02110-1301  USA
  22.  
  23.  
  24.  
  25. ## ---------------- ##
  26. ## Default values.  ##
  27. ## ---------------- ##
  28.  
  29. # Stack parameters.
  30. m4_define_default([b4_stack_depth_max], [10000])
  31. m4_define_default([b4_stack_depth_init],  [200])
  32.  
  33.  
  34. ## ------------------------ ##
  35. ## Pure/impure interfaces.  ##
  36. ## ------------------------ ##
  37.  
  38.  
  39. # b4_pure_if(IF-TRUE, IF-FALSE)
  40. # -----------------------------
  41. # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
  42. m4_define([b4_Pure_if],
  43. [b4_pure_if([m4_ifset([b4_parse_param],
  44.                       [$1], [$2])],
  45.             [$2])])
  46.  
  47.  
  48. # b4_yyerror_args
  49. # ---------------
  50. # Arguments passed to yyerror: user args plus yylloc.
  51. m4_define([b4_yyerror_args],
  52. [b4_Pure_if([b4_location_if([&yylloc, ])])dnl
  53. m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
  54.  
  55.  
  56. # b4_lex_param
  57. # ------------
  58. # Accumulate in b4_lex_param all the yylex arguments.
  59. # b4_lex_param arrives quoted twice, but we want to keep only one level.
  60. m4_define([b4_lex_param],
  61. m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
  62. b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
  63. m4_ifdef([b4_lex_param], b4_lex_param)))
  64.  
  65.  
  66.  
  67. ## ------------ ##
  68. ## Data Types.  ##
  69. ## ------------ ##
  70.  
  71. # b4_int_type(MIN, MAX)
  72. # ---------------------
  73. # Return the smallest int type able to handle numbers ranging from
  74. # MIN to MAX (included).  We overwrite the version from c.m4 which relies
  75. # on "signed char" which is not portable to old K&R compilers.
  76. m4_define([b4_int_type],
  77. [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
  78.        b4_ints_in($@,   [-128],   [127]), [1], [yysigned_char],
  79.  
  80.        b4_ints_in($@,      [0], [65535]), [1], [unsigned short int],
  81.        b4_ints_in($@, [-32768], [32767]), [1], [short int],
  82.  
  83.        m4_eval([0 <= $1]),                [1], [unsigned int],
  84.  
  85.                                            [int])])
  86.  
  87.  
  88. ## ----------------- ##
  89. ## Semantic Values.  ##
  90. ## ----------------- ##
  91.  
  92.  
  93. # b4_lhs_value([TYPE])
  94. # --------------------
  95. # Expansion of $<TYPE>$.
  96. m4_define([b4_lhs_value],
  97. [(yyval[]m4_ifval([$1], [.$1]))])
  98.  
  99.  
  100. # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  101. # --------------------------------------
  102. # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  103. # symbols on RHS.
  104. m4_define([b4_rhs_value],
  105. [(yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3]))])
  106.  
  107.  
  108.  
  109. ## ----------- ##
  110. ## Locations.  ##
  111. ## ----------- ##
  112.  
  113. # b4_lhs_location()
  114. # -----------------
  115. # Expansion of @$.
  116. m4_define([b4_lhs_location],
  117. [(yyloc)])
  118.  
  119.  
  120. # b4_rhs_location(RULE-LENGTH, NUM)
  121. # ---------------------------------
  122. # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  123. # on RHS.
  124. m4_define([b4_rhs_location],
  125. [(yylsp@{m4_eval([$2 - $1])@})])
  126.  
  127.  
  128.  
  129. ## --------------------------------------------------------- ##
  130. ## Defining symbol actions, e.g., printers and destructors.  ##
  131. ## --------------------------------------------------------- ##
  132.  
  133. # We do want M4 expansion after # for CPP macros.
  134. m4_changecom()
  135. m4_divert(0)dnl
  136. @output @output_parser_name@
  137. b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
  138.              [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])[
  139.  
  140. /* As a special exception, when this file is copied by Bison into a
  141.    Bison output file, you may use that output file without restriction.
  142.    This special exception was added by the Free Software Foundation
  143.    in version 1.24 of Bison.  */
  144.  
  145. /* Written by Richard Stallman by simplifying the original so called
  146.    ``semantic'' parser.  */
  147.  
  148. /* All symbols defined below should begin with yy or YY, to avoid
  149.    infringing on user name space.  This should be done even for local
  150.    variables, as they might otherwise be expanded by user macros.
  151.    There are some unavoidable exceptions within include files to
  152.    define necessary library symbols; they are noted "INFRINGES ON
  153.    USER NAME SPACE" below.  */
  154.  
  155. ]b4_identification
  156. m4_if(b4_prefix[], [yy], [],
  157. [/* Substitute the variable and function names.  */
  158. #define yyparse b4_prefix[]parse
  159. #define yylex   b4_prefix[]lex
  160. #define yyerror b4_prefix[]error
  161. #define yylval  b4_prefix[]lval
  162. #define yychar  b4_prefix[]char
  163. #define yydebug b4_prefix[]debug
  164. #define yynerrs b4_prefix[]nerrs
  165. b4_location_if([#define yylloc b4_prefix[]lloc])])[
  166.  
  167. ]b4_token_enums_defines(b4_tokens)[
  168.  
  169. /* Copy the first part of user declarations.  */
  170. ]b4_pre_prologue[
  171.  
  172. /* Enabling traces.  */
  173. #ifndef YYDEBUG
  174. # define YYDEBUG ]b4_debug[
  175. #endif
  176.  
  177. /* Enabling verbose error messages.  */
  178. #ifdef YYERROR_VERBOSE
  179. # undef YYERROR_VERBOSE
  180. # define YYERROR_VERBOSE 1
  181. #else
  182. # define YYERROR_VERBOSE ]b4_error_verbose[
  183. #endif
  184.  
  185. /* Enabling the token table.  */
  186. #ifndef YYTOKEN_TABLE
  187. # define YYTOKEN_TABLE ]b4_token_table[
  188. #endif
  189.  
  190. #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
  191. ]m4_ifdef([b4_stype],
  192. [b4_syncline([b4_stype_line], [b4_file_name])
  193. typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
  194. /* Line __line__ of yacc.c.  */
  195. b4_syncline([@oline@], [@ofile@])],
  196. [typedef int YYSTYPE;])[
  197. # define yystype YYSTYPE /* obsolescent; will be withdrawn */
  198. # define YYSTYPE_IS_DECLARED 1
  199. # define YYSTYPE_IS_TRIVIAL 1
  200. #endif
  201.  
  202. ]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
  203. typedef struct YYLTYPE
  204. {
  205.   int first_line;
  206.   int first_column;
  207.   int last_line;
  208.   int last_column;
  209. } YYLTYPE;
  210. # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
  211. # define YYLTYPE_IS_DECLARED 1
  212. # define YYLTYPE_IS_TRIVIAL 1
  213. #endif
  214. ])[
  215.  
  216. /* Copy the second part of user declarations.  */
  217. ]b4_post_prologue
  218.  
  219. /* Line __line__ of yacc.c.  */
  220. b4_syncline([@oline@], [@ofile@])[
  221.  
  222. #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
  223. # define YYSIZE_T __SIZE_TYPE__
  224. #endif
  225. #if ! defined (YYSIZE_T) && defined (size_t)
  226. # define YYSIZE_T size_t
  227. #endif
  228. #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
  229. # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
  230. # define YYSIZE_T size_t
  231. #endif
  232. #if ! defined (YYSIZE_T)
  233. # define YYSIZE_T unsigned int
  234. #endif
  235.  
  236. #ifndef YY_
  237. # if YYENABLE_NLS
  238. #  if ENABLE_NLS
  239. #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
  240. #   define YY_(msgid) dgettext ("bison-runtime", msgid)
  241. #  endif
  242. # endif
  243. # ifndef YY_
  244. #  define YY_(msgid) msgid
  245. # endif
  246. #endif
  247.  
  248. #if ! defined (yyoverflow) || YYERROR_VERBOSE
  249.  
  250. /* The parser invokes alloca or malloc; define the necessary symbols.  */
  251.  
  252. # ifdef YYSTACK_USE_ALLOCA
  253. #  if YYSTACK_USE_ALLOCA
  254. #   ifdef __GNUC__
  255. #    define YYSTACK_ALLOC __builtin_alloca
  256. #   else
  257. #    define YYSTACK_ALLOC alloca
  258. #    if defined (__STDC__) || defined (__cplusplus)
  259. #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  260. #     define YYINCLUDED_STDLIB_H
  261. #    endif
  262. #   endif
  263. #  endif
  264. # endif
  265.  
  266. # ifdef YYSTACK_ALLOC
  267.    /* Pacify GCC's `empty if-body' warning. */
  268. #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  269. #  ifndef YYSTACK_ALLOC_MAXIMUM
  270.     /* The OS might guarantee only one guard page at the bottom of the stack,
  271.        and a page size can be as small as 4096 bytes.  So we cannot safely
  272.        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
  273.        to allow for a few compiler-allocated temporary stack slots.  */
  274. #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
  275. #  endif
  276. # else
  277. #  define YYSTACK_ALLOC YYMALLOC
  278. #  define YYSTACK_FREE YYFREE
  279. #  ifndef YYSTACK_ALLOC_MAXIMUM
  280. #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
  281. #  endif
  282. #  ifdef __cplusplus
  283. extern "C" {
  284. #  endif
  285. #  ifndef YYMALLOC
  286. #   define YYMALLOC malloc
  287. #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
  288.     && (defined (__STDC__) || defined (__cplusplus)))
  289. void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
  290. #   endif
  291. #  endif
  292. #  ifndef YYFREE
  293. #   define YYFREE free
  294. #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
  295.     && (defined (__STDC__) || defined (__cplusplus)))
  296. void free (void *); /* INFRINGES ON USER NAME SPACE */
  297. #   endif
  298. #  endif
  299. #  ifdef __cplusplus
  300. }
  301. #  endif
  302. # endif
  303. #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
  304.  
  305.  
  306. #if (! defined (yyoverflow) \
  307.      && (! defined (__cplusplus) \
  308.      || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
  309.              && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
  310.  
  311. /* A type that is properly aligned for any stack member.  */
  312. union yyalloc
  313. {
  314.   short int yyss;
  315.   YYSTYPE yyvs;
  316.   ]b4_location_if([  YYLTYPE yyls;
  317. ])dnl
  318. [};
  319.  
  320. /* The size of the maximum gap between one aligned stack and the next.  */
  321. # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
  322.  
  323. /* The size of an array large to enough to hold all stacks, each with
  324.    N elements.  */
  325. ]b4_location_if(
  326. [# define YYSTACK_BYTES(N) \
  327.      ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE))    \
  328.       + 2 * YYSTACK_GAP_MAXIMUM)],
  329. [# define YYSTACK_BYTES(N) \
  330.      ((N) * (sizeof (short int) + sizeof (YYSTYPE))            \
  331.       + YYSTACK_GAP_MAXIMUM)])[
  332.  
  333. /* Copy COUNT objects from FROM to TO.  The source and destination do
  334.    not overlap.  */
  335. # ifndef YYCOPY
  336. #  if defined (__GNUC__) && 1 < __GNUC__
  337. #   define YYCOPY(To, From, Count) \
  338.       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
  339. #  else
  340. #   define YYCOPY(To, From, Count)        \
  341.       do                    \
  342.     {                    \
  343.       YYSIZE_T yyi;                \
  344.       for (yyi = 0; yyi < (Count); yyi++)    \
  345.         (To)[yyi] = (From)[yyi];        \
  346.     }                    \
  347.       while (0)
  348. #  endif
  349. # endif
  350.  
  351. /* Relocate STACK from its old location to the new one.  The
  352.    local variables YYSIZE and YYSTACKSIZE give the old and new number of
  353.    elements in the stack, and YYPTR gives the new location of the
  354.    stack.  Advance YYPTR to a properly aligned location for the next
  355.    stack.  */
  356. # define YYSTACK_RELOCATE(Stack)                    \
  357.     do                                    \
  358.       {                                    \
  359.     YYSIZE_T yynewbytes;                        \
  360.     YYCOPY (&yyptr->Stack, Stack, yysize);                \
  361.     Stack = &yyptr->Stack;                        \
  362.     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
  363.     yyptr += yynewbytes / sizeof (*yyptr);                \
  364.       }                                    \
  365.     while (0)
  366.  
  367. #endif
  368.  
  369. #if defined (__STDC__) || defined (__cplusplus)
  370.    typedef signed char yysigned_char;
  371. #else
  372.    typedef short int yysigned_char;
  373. #endif
  374.  
  375. /* YYFINAL -- State number of the termination state. */
  376. #define YYFINAL  ]b4_final_state_number[
  377. /* YYLAST -- Last index in YYTABLE.  */
  378. #define YYLAST   ]b4_last[
  379.  
  380. /* YYNTOKENS -- Number of terminals. */
  381. #define YYNTOKENS  ]b4_tokens_number[
  382. /* YYNNTS -- Number of nonterminals. */
  383. #define YYNNTS  ]b4_nterms_number[
  384. /* YYNRULES -- Number of rules. */
  385. #define YYNRULES  ]b4_rules_number[
  386. /* YYNRULES -- Number of states. */
  387. #define YYNSTATES  ]b4_states_number[
  388.  
  389. /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
  390. #define YYUNDEFTOK  ]b4_undef_token_number[
  391. #define YYMAXUTOK   ]b4_user_token_number_max[
  392.  
  393. #define YYTRANSLATE(YYX)                        \
  394.   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
  395.  
  396. /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
  397. static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
  398. {
  399.   ]b4_translate[
  400. };
  401.  
  402. #if YYDEBUG
  403. /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
  404.    YYRHS.  */
  405. static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
  406. {
  407.   ]b4_prhs[
  408. };
  409.  
  410. /* YYRHS -- A `-1'-separated list of the rules' RHS. */
  411. static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
  412. {
  413.   ]b4_rhs[
  414. };
  415.  
  416. /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
  417. static const ]b4_int_type_for([b4_rline])[ yyrline[] =
  418. {
  419.   ]b4_rline[
  420. };
  421. #endif
  422.  
  423. #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
  424. /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
  425.    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
  426. static const char *const yytname[] =
  427. {
  428.   ]b4_tname[
  429. };
  430. #endif
  431.  
  432. # ifdef YYPRINT
  433. /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
  434.    token YYLEX-NUM.  */
  435. static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
  436. {
  437.   ]b4_toknum[
  438. };
  439. # endif
  440.  
  441. /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  442. static const ]b4_int_type_for([b4_r1])[ yyr1[] =
  443. {
  444.   ]b4_r1[
  445. };
  446.  
  447. /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
  448. static const ]b4_int_type_for([b4_r2])[ yyr2[] =
  449. {
  450.   ]b4_r2[
  451. };
  452.  
  453. /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
  454.    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
  455.    means the default is an error.  */
  456. static const ]b4_int_type_for([b4_defact])[ yydefact[] =
  457. {
  458.   ]b4_defact[
  459. };
  460.  
  461. /* YYDEFGOTO[NTERM-NUM]. */
  462. static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
  463. {
  464.   ]b4_defgoto[
  465. };
  466.  
  467. /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
  468.    STATE-NUM.  */
  469. #define YYPACT_NINF ]b4_pact_ninf[
  470. static const ]b4_int_type_for([b4_pact])[ yypact[] =
  471. {
  472.   ]b4_pact[
  473. };
  474.  
  475. /* YYPGOTO[NTERM-NUM].  */
  476. static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
  477. {
  478.   ]b4_pgoto[
  479. };
  480.  
  481. /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
  482.    positive, shift that token.  If negative, reduce the rule which
  483.    number is the opposite.  If zero, do what YYDEFACT says.
  484.    If YYTABLE_NINF, syntax error.  */
  485. #define YYTABLE_NINF ]b4_table_ninf[
  486. static const ]b4_int_type_for([b4_table])[ yytable[] =
  487. {
  488.   ]b4_table[
  489. };
  490.  
  491. static const ]b4_int_type_for([b4_check])[ yycheck[] =
  492. {
  493.   ]b4_check[
  494. };
  495.  
  496. /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
  497.    symbol of state STATE-NUM.  */
  498. static const ]b4_int_type_for([b4_stos])[ yystos[] =
  499. {
  500.   ]b4_stos[
  501. };
  502.  
  503. #define yyerrok        (yyerrstatus = 0)
  504. #define yyclearin    (yychar = YYEMPTY)
  505. #define YYEMPTY        (-2)
  506. #define YYEOF        0
  507.  
  508. #define YYACCEPT    goto yyacceptlab
  509. #define YYABORT        goto yyabortlab
  510. #define YYERROR        goto yyerrorlab
  511.  
  512.  
  513. /* Like YYERROR except do call yyerror.  This remains here temporarily
  514.    to ease the transition to the new meaning of YYERROR, for GCC.
  515.    Once GCC version 2 has supplanted version 1, this can go.  */
  516.  
  517. #define YYFAIL        goto yyerrlab
  518.  
  519. #define YYRECOVERING()  (!!yyerrstatus)
  520.  
  521. #define YYBACKUP(Token, Value)                    \
  522. do                                \
  523.   if (yychar == YYEMPTY && yylen == 1)                \
  524.     {                                \
  525.       yychar = (Token);                        \
  526.       yylval = (Value);                        \
  527.       yytoken = YYTRANSLATE (yychar);                \
  528.       YYPOPSTACK;                        \
  529.       goto yybackup;                        \
  530.     }                                \
  531.   else                                \
  532.     {                                \
  533.       yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
  534.       YYERROR;                            \
  535.     }                                \
  536. while (0)
  537.  
  538.  
  539. #define YYTERROR    1
  540. #define YYERRCODE    256
  541.  
  542.  
  543. /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
  544.    If N is 0, then set CURRENT to the empty location which ends
  545.    the previous symbol: RHS[0] (always defined).  */
  546.  
  547. #define YYRHSLOC(Rhs, K) ((Rhs)[K])
  548. #ifndef YYLLOC_DEFAULT
  549. # define YYLLOC_DEFAULT(Current, Rhs, N)                \
  550.     do                                    \
  551.       if (N)                                \
  552.     {                                \
  553.       (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
  554.       (Current).first_column = YYRHSLOC (Rhs, 1).first_column;    \
  555.       (Current).last_line    = YYRHSLOC (Rhs, N).last_line;        \
  556.       (Current).last_column  = YYRHSLOC (Rhs, N).last_column;    \
  557.     }                                \
  558.       else                                \
  559.     {                                \
  560.       (Current).first_line   = (Current).last_line   =        \
  561.         YYRHSLOC (Rhs, 0).last_line;                \
  562.       (Current).first_column = (Current).last_column =        \
  563.         YYRHSLOC (Rhs, 0).last_column;                \
  564.     }                                \
  565.     while (0)
  566. #endif
  567.  
  568.  
  569. /* YY_LOCATION_PRINT -- Print the location on the stream.
  570.    This macro was not mandated originally: define only if we know
  571.    we won't break user code: when these are the locations we know.  */
  572.  
  573. #ifndef YY_LOCATION_PRINT
  574. # if YYLTYPE_IS_TRIVIAL
  575. #  define YY_LOCATION_PRINT(File, Loc)            \
  576.      fprintf (File, "%d.%d-%d.%d",            \
  577.               (Loc).first_line, (Loc).first_column,    \
  578.               (Loc).last_line,  (Loc).last_column)
  579. # else
  580. #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  581. # endif
  582. #endif
  583.  
  584.  
  585. /* YYLEX -- calling `yylex' with the right arguments.  */
  586.  
  587. #ifdef YYLEX_PARAM
  588. # define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
  589. #else
  590. # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
  591. #endif
  592.  
  593. /* Enable debugging if requested.  */
  594. #if YYDEBUG
  595.  
  596. # ifndef YYFPRINTF
  597. #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  598. #  define YYFPRINTF fprintf
  599. # endif
  600.  
  601. # define YYDPRINTF(Args)            \
  602. do {                        \
  603.   if (yydebug)                    \
  604.     YYFPRINTF Args;                \
  605. } while (0)
  606.  
  607. # define YY_SYMBOL_PRINT(Title, Type, Value, Location)        \
  608. do {                                \
  609.   if (yydebug)                            \
  610.     {                                \
  611.       YYFPRINTF (stderr, "%s ", Title);                \
  612.       yysymprint (stderr,                    \
  613.                   Type, Value]b4_location_if([, Location])[);    \
  614.       YYFPRINTF (stderr, "\n");                    \
  615.     }                                \
  616. } while (0)
  617.  
  618. /*------------------------------------------------------------------.
  619. | yy_stack_print -- Print the state stack from its BOTTOM up to its |
  620. | TOP (included).                                                   |
  621. `------------------------------------------------------------------*/
  622.  
  623. ]b4_c_function_def([yy_stack_print], [static void],
  624.                    [[short int *bottom], [bottom]],
  625.                    [[short int *top],    [top]])[
  626. {
  627.   YYFPRINTF (stderr, "Stack now");
  628.   for (/* Nothing. */; bottom <= top; ++bottom)
  629.     YYFPRINTF (stderr, " %d", *bottom);
  630.   YYFPRINTF (stderr, "\n");
  631. }
  632.  
  633. # define YY_STACK_PRINT(Bottom, Top)                \
  634. do {                                \
  635.   if (yydebug)                            \
  636.     yy_stack_print ((Bottom), (Top));                \
  637. } while (0)
  638.  
  639.  
  640. /*------------------------------------------------.
  641. | Report that the YYRULE is going to be reduced.  |
  642. `------------------------------------------------*/
  643.  
  644. ]b4_c_function_def([yy_reduce_print], [static void],
  645.                    [[int yyrule], [yyrule]])[
  646. {
  647.   int yyi;
  648.   unsigned long int yylno = yyrline[yyrule];
  649.   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
  650.              yyrule - 1, yylno);
  651.   /* Print the symbols being reduced, and their result.  */
  652.   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
  653.     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
  654.   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
  655. }
  656.  
  657. # define YY_REDUCE_PRINT(Rule)        \
  658. do {                    \
  659.   if (yydebug)                \
  660.     yy_reduce_print (Rule);        \
  661. } while (0)
  662.  
  663. /* Nonzero means print parse trace.  It is left uninitialized so that
  664.    multiple parsers can coexist.  */
  665. int yydebug;
  666. #else /* !YYDEBUG */
  667. # define YYDPRINTF(Args)
  668. # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  669. # define YY_STACK_PRINT(Bottom, Top)
  670. # define YY_REDUCE_PRINT(Rule)
  671. #endif /* !YYDEBUG */
  672.  
  673.  
  674. /* YYINITDEPTH -- initial size of the parser's stacks.  */
  675. #ifndef    YYINITDEPTH
  676. # define YYINITDEPTH ]b4_stack_depth_init[
  677. #endif
  678.  
  679. /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
  680.    if the built-in stack extension method is used).
  681.  
  682.    Do not make this value too large; the results are undefined if
  683.    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
  684.    evaluated with infinite-precision integer arithmetic.  */
  685.  
  686. #ifndef YYMAXDEPTH
  687. # define YYMAXDEPTH ]b4_stack_depth_max[
  688. #endif
  689.  
  690.  
  691.  
  692. #if YYERROR_VERBOSE
  693.  
  694. # ifndef yystrlen
  695. #  if defined (__GLIBC__) && defined (_STRING_H)
  696. #   define yystrlen strlen
  697. #  else
  698. /* Return the length of YYSTR.  */
  699. static YYSIZE_T
  700. #   if defined (__STDC__) || defined (__cplusplus)
  701. yystrlen (const char *yystr)
  702. #   else
  703. yystrlen (yystr)
  704.      const char *yystr;
  705. #   endif
  706. {
  707.   const char *yys = yystr;
  708.  
  709.   while (*yys++ != '\0')
  710.     continue;
  711.  
  712.   return yys - yystr - 1;
  713. }
  714. #  endif
  715. # endif
  716.  
  717. # ifndef yystpcpy
  718. #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
  719. #   define yystpcpy stpcpy
  720. #  else
  721. /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
  722.    YYDEST.  */
  723. static char *
  724. #   if defined (__STDC__) || defined (__cplusplus)
  725. yystpcpy (char *yydest, const char *yysrc)
  726. #   else
  727. yystpcpy (yydest, yysrc)
  728.      char *yydest;
  729.      const char *yysrc;
  730. #   endif
  731. {
  732.   char *yyd = yydest;
  733.   const char *yys = yysrc;
  734.  
  735.   while ((*yyd++ = *yys++) != '\0')
  736.     continue;
  737.  
  738.   return yyd - 1;
  739. }
  740. #  endif
  741. # endif
  742.  
  743. # ifndef yytnamerr
  744. /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
  745.    quotes and backslashes, so that it's suitable for yyerror.  The
  746.    heuristic is that double-quoting is unnecessary unless the string
  747.    contains an apostrophe, a comma, or backslash (other than
  748.    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
  749.    null, do not copy; instead, return the length of what the result
  750.    would have been.  */
  751. static YYSIZE_T
  752. yytnamerr (char *yyres, const char *yystr)
  753. {
  754.   if (*yystr == '"')
  755.     {
  756.       size_t yyn = 0;
  757.       char const *yyp = yystr;
  758.  
  759.       for (;;)
  760.     switch (*++yyp)
  761.       {
  762.       case '\'':
  763.       case ',':
  764.         goto do_not_strip_quotes;
  765.  
  766.       case '\\':
  767.         if (*++yyp != '\\')
  768.           goto do_not_strip_quotes;
  769.         /* Fall through.  */
  770.       default:
  771.         if (yyres)
  772.           yyres[yyn] = *yyp;
  773.         yyn++;
  774.         break;
  775.  
  776.       case '"':
  777.         if (yyres)
  778.           yyres[yyn] = '\0';
  779.         return yyn;
  780.       }
  781.     do_not_strip_quotes: ;
  782.     }
  783.  
  784.   if (! yyres)
  785.     return yystrlen (yystr);
  786.  
  787.   return yystpcpy (yyres, yystr) - yyres;
  788. }
  789. # endif
  790.  
  791. #endif /* YYERROR_VERBOSE */
  792.  
  793.  
  794.  
  795. #if YYDEBUG
  796. ]b4_yysymprint_generate([b4_c_function_def])[
  797. #endif /* ! YYDEBUG */
  798. ]b4_yydestruct_generate([b4_c_function_def])
  799.  
  800.  
  801. /* Prevent warnings from -Wmissing-prototypes.  */
  802.  
  803. #ifdef YYPARSE_PARAM
  804. # if defined (__STDC__) || defined (__cplusplus)
  805. int yyparse (void *YYPARSE_PARAM);
  806. # else
  807. int yyparse ();
  808. # endif
  809. #else /* ! YYPARSE_PARAM */
  810. b4_c_function_decl([yyparse], [int], b4_parse_param)
  811. #endif /* ! YYPARSE_PARAM */
  812.  
  813.  
  814. m4_divert_push([KILL])# ======================== M4 code.
  815. # b4_declare_parser_variables
  816. # ---------------------------
  817. # Declare the variables that are global, or local to YYPARSE if
  818. # pure-parser.
  819. m4_define([b4_declare_parser_variables],
  820. [/* The look-ahead symbol.  */
  821. int yychar;
  822.  
  823. /* The semantic value of the look-ahead symbol.  */
  824. YYSTYPE yylval;
  825.  
  826. /* Number of syntax errors so far.  */
  827. int yynerrs;b4_location_if([
  828. /* Location data for the look-ahead symbol.  */
  829. YYLTYPE yylloc;])
  830. ])
  831. m4_divert_pop([KILL])dnl# ====================== End of M4 code.
  832.  
  833. b4_pure_if([],
  834.            [b4_declare_parser_variables])
  835.  
  836.  
  837. /*----------.
  838. | yyparse.  |
  839. `----------*/
  840.  
  841. #ifdef YYPARSE_PARAM
  842. # if defined (__STDC__) || defined (__cplusplus)
  843. int yyparse (void *YYPARSE_PARAM)
  844. # else
  845. int yyparse (YYPARSE_PARAM)
  846.   void *YYPARSE_PARAM;
  847. # endif
  848. #else /* ! YYPARSE_PARAM */
  849. b4_c_function_def([yyparse], [int], b4_parse_param)
  850. #endif
  851. {[
  852.   ]b4_pure_if([b4_declare_parser_variables])[
  853.   int yystate;
  854.   int yyn;
  855.   int yyresult;
  856.   /* Number of tokens to shift before error messages enabled.  */
  857.   int yyerrstatus;
  858.   /* Look-ahead token as an internal (translated) token number.  */
  859.   int yytoken = 0;
  860.  
  861.   /* Three stacks and their tools:
  862.      `yyss': related to states,
  863.      `yyvs': related to semantic values,
  864.      `yyls': related to locations.
  865.  
  866.      Refer to the stacks thru separate pointers, to allow yyoverflow
  867.      to reallocate them elsewhere.  */
  868.  
  869.   /* The state stack.  */
  870.   short int yyssa[YYINITDEPTH];
  871.   short int *yyss = yyssa;
  872.   short int *yyssp;
  873.  
  874.   /* The semantic value stack.  */
  875.   YYSTYPE yyvsa[YYINITDEPTH];
  876.   YYSTYPE *yyvs = yyvsa;
  877.   YYSTYPE *yyvsp;
  878.  
  879. ]b4_location_if(
  880. [[  /* The location stack.  */
  881.   YYLTYPE yylsa[YYINITDEPTH];
  882.   YYLTYPE *yyls = yylsa;
  883.   YYLTYPE *yylsp;
  884.   /* The locations where the error started and ended. */
  885.   YYLTYPE yyerror_range[2];]])[
  886.  
  887. #define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
  888.  
  889.   YYSIZE_T yystacksize = YYINITDEPTH;
  890.  
  891.   /* The variables used to return semantic value and location from the
  892.      action routines.  */
  893.   YYSTYPE yyval;
  894. ]b4_location_if([  YYLTYPE yyloc;])[
  895.  
  896.   /* When reducing, the number of symbols on the RHS of the reduced
  897.      rule.  */
  898.   int yylen;
  899.  
  900.   YYDPRINTF ((stderr, "Starting parse\n"));
  901.  
  902.   yystate = 0;
  903.   yyerrstatus = 0;
  904.   yynerrs = 0;
  905.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  906.  
  907.   /* Initialize stack pointers.
  908.      Waste one element of value and location stack
  909.      so that they stay on the same level as the state stack.
  910.      The wasted elements are never initialized.  */
  911.  
  912.   yyssp = yyss;
  913.   yyvsp = yyvs;
  914. ]b4_location_if([[  yylsp = yyls;
  915. #if YYLTYPE_IS_TRIVIAL
  916.   /* Initialize the default location before parsing starts.  */
  917.   yylloc.first_line   = yylloc.last_line   = 1;
  918.   yylloc.first_column = yylloc.last_column = 0;
  919. #endif
  920. ]])
  921. m4_ifdef([b4_initial_action], [
  922. m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
  923. m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
  924.   /* User initialization code. */
  925. b4_initial_action
  926. m4_popdef([b4_dollar_dollar])dnl
  927. m4_popdef([b4_at_dollar])dnl
  928. /* Line __line__ of yacc.c.  */
  929. b4_syncline([@oline@], [@ofile@])
  930. ])dnl
  931. m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
  932. ]])dnl
  933. m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
  934. ]])dnl
  935. [  goto yysetstate;
  936.  
  937. /*------------------------------------------------------------.
  938. | yynewstate -- Push a new state, which is found in yystate.  |
  939. `------------------------------------------------------------*/
  940.  yynewstate:
  941.   /* In all cases, when you get here, the value and location stacks
  942.      have just been pushed. so pushing a state here evens the stacks.
  943.      */
  944.   yyssp++;
  945.  
  946.  yysetstate:
  947.   *yyssp = yystate;
  948.  
  949.   if (yyss + yystacksize - 1 <= yyssp)
  950.     {
  951.       /* Get the current used size of the three stacks, in elements.  */
  952.       YYSIZE_T yysize = yyssp - yyss + 1;
  953.  
  954. #ifdef yyoverflow
  955.       {
  956.     /* Give user a chance to reallocate the stack. Use copies of
  957.        these so that the &'s don't force the real ones into
  958.        memory.  */
  959.     YYSTYPE *yyvs1 = yyvs;
  960.     short int *yyss1 = yyss;
  961. ]b4_location_if([    YYLTYPE *yyls1 = yyls;])[
  962.  
  963.     /* Each stack pointer address is followed by the size of the
  964.        data in use in that stack, in bytes.  This used to be a
  965.        conditional around just the two extra args, but that might
  966.        be undefined if yyoverflow is a macro.  */
  967.     yyoverflow (YY_("memory exhausted"),
  968.             &yyss1, yysize * sizeof (*yyssp),
  969.             &yyvs1, yysize * sizeof (*yyvsp),
  970. ]b4_location_if([            &yyls1, yysize * sizeof (*yylsp),])[
  971.             &yystacksize);
  972. ]b4_location_if([    yyls = yyls1;])[
  973.     yyss = yyss1;
  974.     yyvs = yyvs1;
  975.       }
  976. #else /* no yyoverflow */
  977. # ifndef YYSTACK_RELOCATE
  978.       goto yyexhaustedlab;
  979. # else
  980.       /* Extend the stack our own way.  */
  981.       if (YYMAXDEPTH <= yystacksize)
  982.     goto yyexhaustedlab;
  983.       yystacksize *= 2;
  984.       if (YYMAXDEPTH < yystacksize)
  985.     yystacksize = YYMAXDEPTH;
  986.  
  987.       {
  988.     short int *yyss1 = yyss;
  989.     union yyalloc *yyptr =
  990.       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
  991.     if (! yyptr)
  992.       goto yyexhaustedlab;
  993.     YYSTACK_RELOCATE (yyss);
  994.     YYSTACK_RELOCATE (yyvs);
  995. ]b4_location_if([    YYSTACK_RELOCATE (yyls);])[
  996. #  undef YYSTACK_RELOCATE
  997.     if (yyss1 != yyssa)
  998.       YYSTACK_FREE (yyss1);
  999.       }
  1000. # endif
  1001. #endif /* no yyoverflow */
  1002.  
  1003.       yyssp = yyss + yysize - 1;
  1004.       yyvsp = yyvs + yysize - 1;
  1005. ]b4_location_if([      yylsp = yyls + yysize - 1;])[
  1006.  
  1007.       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
  1008.           (unsigned long int) yystacksize));
  1009.  
  1010.       if (yyss + yystacksize - 1 <= yyssp)
  1011.     YYABORT;
  1012.     }
  1013.  
  1014.   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  1015.  
  1016.   goto yybackup;
  1017.  
  1018. /*-----------.
  1019. | yybackup.  |
  1020. `-----------*/
  1021. yybackup:
  1022.  
  1023. /* Do appropriate processing given the current state.  */
  1024. /* Read a look-ahead token if we need one and don't already have one.  */
  1025. /* yyresume: */
  1026.  
  1027.   /* First try to decide what to do without reference to look-ahead token.  */
  1028.  
  1029.   yyn = yypact[yystate];
  1030.   if (yyn == YYPACT_NINF)
  1031.     goto yydefault;
  1032.  
  1033.   /* Not known => get a look-ahead token if don't already have one.  */
  1034.  
  1035.   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
  1036.   if (yychar == YYEMPTY)
  1037.     {
  1038.       YYDPRINTF ((stderr, "Reading a token: "));
  1039.       yychar = YYLEX;
  1040.     }
  1041.  
  1042.   if (yychar <= YYEOF)
  1043.     {
  1044.       yychar = yytoken = YYEOF;
  1045.       YYDPRINTF ((stderr, "Now at end of input.\n"));
  1046.     }
  1047.   else
  1048.     {
  1049.       yytoken = YYTRANSLATE (yychar);
  1050.       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
  1051.     }
  1052.  
  1053.   /* If the proper action on seeing token YYTOKEN is to reduce or to
  1054.      detect an error, take that action.  */
  1055.   yyn += yytoken;
  1056.   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
  1057.     goto yydefault;
  1058.   yyn = yytable[yyn];
  1059.   if (yyn <= 0)
  1060.     {
  1061.       if (yyn == 0 || yyn == YYTABLE_NINF)
  1062.     goto yyerrlab;
  1063.       yyn = -yyn;
  1064.       goto yyreduce;
  1065.     }
  1066.  
  1067.   if (yyn == YYFINAL)
  1068.     YYACCEPT;
  1069.  
  1070.   /* Shift the look-ahead token.  */
  1071.   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  1072.  
  1073.   /* Discard the token being shifted unless it is eof.  */
  1074.   if (yychar != YYEOF)
  1075.     yychar = YYEMPTY;
  1076.  
  1077.   *++yyvsp = yylval;
  1078. ]b4_location_if([  *++yylsp = yylloc;])[
  1079.  
  1080.   /* Count tokens shifted since error; after three, turn off error
  1081.      status.  */
  1082.   if (yyerrstatus)
  1083.     yyerrstatus--;
  1084.  
  1085.   yystate = yyn;
  1086.   goto yynewstate;
  1087.  
  1088.  
  1089. /*-----------------------------------------------------------.
  1090. | yydefault -- do the default action for the current state.  |
  1091. `-----------------------------------------------------------*/
  1092. yydefault:
  1093.   yyn = yydefact[yystate];
  1094.   if (yyn == 0)
  1095.     goto yyerrlab;
  1096.   goto yyreduce;
  1097.  
  1098.  
  1099. /*-----------------------------.
  1100. | yyreduce -- Do a reduction.  |
  1101. `-----------------------------*/
  1102. yyreduce:
  1103.   /* yyn is the number of a rule to reduce with.  */
  1104.   yylen = yyr2[yyn];
  1105.  
  1106.   /* If YYLEN is nonzero, implement the default value of the action:
  1107.      `$$ = $1'.
  1108.  
  1109.      Otherwise, the following line sets YYVAL to garbage.
  1110.      This behavior is undocumented and Bison
  1111.      users should not rely upon it.  Assigning to YYVAL
  1112.      unconditionally makes the parser a bit smaller, and it avoids a
  1113.      GCC warning that YYVAL may be used uninitialized.  */
  1114.   yyval = yyvsp[1-yylen];
  1115.  
  1116. ]b4_location_if(
  1117. [[  /* Default location. */
  1118.   YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
  1119.   YY_REDUCE_PRINT (yyn);
  1120.   switch (yyn)
  1121.     ]{
  1122.       b4_actions
  1123.       default: break;
  1124.     }
  1125.  
  1126. /* Line __line__ of yacc.c.  */
  1127. b4_syncline([@oline@], [@ofile@])
  1128.  
  1129. [  yyvsp -= yylen;
  1130.   yyssp -= yylen;
  1131. ]b4_location_if([  yylsp -= yylen;])[
  1132.  
  1133.   YY_STACK_PRINT (yyss, yyssp);
  1134.  
  1135.   *++yyvsp = yyval;
  1136. ]b4_location_if([  *++yylsp = yyloc;])[
  1137.  
  1138.   /* Now `shift' the result of the reduction.  Determine what state
  1139.      that goes to, based on the state we popped back to and the rule
  1140.      number reduced by.  */
  1141.  
  1142.   yyn = yyr1[yyn];
  1143.  
  1144.   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
  1145.   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  1146.     yystate = yytable[yystate];
  1147.   else
  1148.     yystate = yydefgoto[yyn - YYNTOKENS];
  1149.  
  1150.   goto yynewstate;
  1151.  
  1152.  
  1153. /*------------------------------------.
  1154. | yyerrlab -- here on detecting error |
  1155. `------------------------------------*/
  1156. yyerrlab:
  1157.   /* If not already recovering from an error, report this error.  */
  1158.   if (!yyerrstatus)
  1159.     {
  1160.       ++yynerrs;
  1161. #if YYERROR_VERBOSE
  1162.       yyn = yypact[yystate];
  1163.  
  1164.       if (YYPACT_NINF < yyn && yyn < YYLAST)
  1165.     {
  1166.       int yytype = YYTRANSLATE (yychar);
  1167.       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
  1168.       YYSIZE_T yysize = yysize0;
  1169.       YYSIZE_T yysize1;
  1170.       int yysize_overflow = 0;
  1171.       char *yymsg = 0;
  1172. #      define YYERROR_VERBOSE_ARGS_MAXIMUM 5
  1173.       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  1174.       int yyx;
  1175.  
  1176. #if 0
  1177.       /* This is so xgettext sees the translatable formats that are
  1178.          constructed on the fly.  */
  1179.       YY_("syntax error, unexpected %s");
  1180.       YY_("syntax error, unexpected %s, expecting %s");
  1181.       YY_("syntax error, unexpected %s, expecting %s or %s");
  1182.       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
  1183.       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
  1184. #endif
  1185.       char *yyfmt;
  1186.       char const *yyf;
  1187.       static char const yyunexpected[] = "syntax error, unexpected %s";
  1188.       static char const yyexpecting[] = ", expecting %s";
  1189.       static char const yyor[] = " or %s";
  1190.       char yyformat[sizeof yyunexpected
  1191.             + sizeof yyexpecting - 1
  1192.             + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
  1193.                * (sizeof yyor - 1))];
  1194.       char const *yyprefix = yyexpecting;
  1195.  
  1196.       /* Start YYX at -YYN if negative to avoid negative indexes in
  1197.          YYCHECK.  */
  1198.       int yyxbegin = yyn < 0 ? -yyn : 0;
  1199.  
  1200.       /* Stay within bounds of both yycheck and yytname.  */
  1201.       int yychecklim = YYLAST - yyn;
  1202.       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
  1203.       int yycount = 1;
  1204.  
  1205.       yyarg[0] = yytname[yytype];
  1206.       yyfmt = yystpcpy (yyformat, yyunexpected);
  1207.  
  1208.       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
  1209.         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
  1210.           {
  1211.         if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
  1212.           {
  1213.             yycount = 1;
  1214.             yysize = yysize0;
  1215.             yyformat[sizeof yyunexpected - 1] = '\0';
  1216.             break;
  1217.           }
  1218.         yyarg[yycount++] = yytname[yyx];
  1219.         yysize1 = yysize + yytnamerr (0, yytname[yyx]);
  1220.         yysize_overflow |= yysize1 < yysize;
  1221.         yysize = yysize1;
  1222.         yyfmt = yystpcpy (yyfmt, yyprefix);
  1223.         yyprefix = yyor;
  1224.           }
  1225.  
  1226.       yyf = YY_(yyformat);
  1227.       yysize1 = yysize + yystrlen (yyf);
  1228.       yysize_overflow |= yysize1 < yysize;
  1229.       yysize = yysize1;
  1230.  
  1231.       if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
  1232.         yymsg = (char *) YYSTACK_ALLOC (yysize);
  1233.       if (yymsg)
  1234.         {
  1235.           /* Avoid sprintf, as that infringes on the user's name space.
  1236.          Don't have undefined behavior even if the translation
  1237.          produced a string with the wrong number of "%s"s.  */
  1238.           char *yyp = yymsg;
  1239.           int yyi = 0;
  1240.           while ((*yyp = *yyf))
  1241.         {
  1242.           if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
  1243.             {
  1244.               yyp += yytnamerr (yyp, yyarg[yyi++]);
  1245.               yyf += 2;
  1246.             }
  1247.           else
  1248.             {
  1249.               yyp++;
  1250.               yyf++;
  1251.             }
  1252.         }
  1253.           yyerror (]b4_yyerror_args[yymsg);
  1254.           YYSTACK_FREE (yymsg);
  1255.         }
  1256.       else
  1257.         {
  1258.           yyerror (]b4_yyerror_args[YY_("syntax error"));
  1259.           goto yyexhaustedlab;
  1260.         }
  1261.     }
  1262.       else
  1263. #endif /* YYERROR_VERBOSE */
  1264.     yyerror (]b4_yyerror_args[YY_("syntax error"));
  1265.     }
  1266.  
  1267. ]b4_location_if([[  yyerror_range[0] = yylloc;]])[
  1268.  
  1269.   if (yyerrstatus == 3)
  1270.     {
  1271.       /* If just tried and failed to reuse look-ahead token after an
  1272.      error, discard it.  */
  1273.  
  1274.       if (yychar <= YYEOF)
  1275.         {
  1276.       /* Return failure if at end of input.  */
  1277.       if (yychar == YYEOF)
  1278.         YYABORT;
  1279.         }
  1280.       else
  1281.     {
  1282.       yydestruct ("Error: discarding", yytoken, &yylval]b4_location_if([, &yylloc])[);
  1283.       yychar = YYEMPTY;
  1284.     }
  1285.     }
  1286.  
  1287.   /* Else will try to reuse look-ahead token after shifting the error
  1288.      token.  */
  1289.   goto yyerrlab1;
  1290.  
  1291.  
  1292. /*---------------------------------------------------.
  1293. | yyerrorlab -- error raised explicitly by YYERROR.  |
  1294. `---------------------------------------------------*/
  1295. yyerrorlab:
  1296.  
  1297.   /* Pacify compilers like GCC when the user code never invokes
  1298.      YYERROR and the label yyerrorlab therefore never appears in user
  1299.      code.  */
  1300.   if (0)
  1301.      goto yyerrorlab;
  1302.  
  1303. ]b4_location_if([[  yyerror_range[0] = yylsp[1-yylen];
  1304.   yylsp -= yylen;
  1305.   ]])[yyvsp -= yylen;
  1306.   yyssp -= yylen;
  1307.   yystate = *yyssp;
  1308.   goto yyerrlab1;
  1309.  
  1310.  
  1311. /*-------------------------------------------------------------.
  1312. | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  1313. `-------------------------------------------------------------*/
  1314. yyerrlab1:
  1315.   yyerrstatus = 3;    /* Each real token shifted decrements this.  */
  1316.  
  1317.   for (;;)
  1318.     {
  1319.       yyn = yypact[yystate];
  1320.       if (yyn != YYPACT_NINF)
  1321.     {
  1322.       yyn += YYTERROR;
  1323.       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
  1324.         {
  1325.           yyn = yytable[yyn];
  1326.           if (0 < yyn)
  1327.         break;
  1328.         }
  1329.     }
  1330.  
  1331.       /* Pop the current state because it cannot handle the error token.  */
  1332.       if (yyssp == yyss)
  1333.     YYABORT;
  1334.  
  1335. ]b4_location_if([[      yyerror_range[0] = *yylsp;]])[
  1336.       yydestruct ("Error: popping", yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
  1337.       YYPOPSTACK;
  1338.       yystate = *yyssp;
  1339.       YY_STACK_PRINT (yyss, yyssp);
  1340.     }
  1341.  
  1342.   if (yyn == YYFINAL)
  1343.     YYACCEPT;
  1344.  
  1345.   *++yyvsp = yylval;
  1346. ]b4_location_if([[
  1347.   yyerror_range[1] = yylloc;
  1348.   /* Using YYLLOC is tempting, but would change the location of
  1349.      the look-ahead.  YYLOC is available though. */
  1350.   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
  1351.   *++yylsp = yyloc;]])[
  1352.  
  1353.   /* Shift the error token. */
  1354.   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
  1355.  
  1356.   yystate = yyn;
  1357.   goto yynewstate;
  1358.  
  1359.  
  1360. /*-------------------------------------.
  1361. | yyacceptlab -- YYACCEPT comes here.  |
  1362. `-------------------------------------*/
  1363. yyacceptlab:
  1364.   yyresult = 0;
  1365.   goto yyreturn;
  1366.  
  1367. /*-----------------------------------.
  1368. | yyabortlab -- YYABORT comes here.  |
  1369. `-----------------------------------*/
  1370. yyabortlab:
  1371.   yyresult = 1;
  1372.   goto yyreturn;
  1373.  
  1374. #ifndef yyoverflow
  1375. /*-------------------------------------------------.
  1376. | yyexhaustedlab -- memory exhaustion comes here.  |
  1377. `-------------------------------------------------*/
  1378. yyexhaustedlab:
  1379.   yyerror (]b4_yyerror_args[YY_("memory exhausted"));
  1380.   yyresult = 2;
  1381.   /* Fall through.  */
  1382. #endif
  1383.  
  1384. yyreturn:
  1385.   if (yychar != YYEOF && yychar != YYEMPTY)
  1386.      yydestruct ("Cleanup: discarding lookahead",
  1387.          yytoken, &yylval]b4_location_if([, &yylloc])[);
  1388.   while (yyssp != yyss)
  1389.     {
  1390.       yydestruct ("Cleanup: popping",
  1391.           yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
  1392.       YYPOPSTACK;
  1393.     }
  1394. #ifndef yyoverflow
  1395.   if (yyss != yyssa)
  1396.     YYSTACK_FREE (yyss);
  1397. #endif
  1398.   return yyresult;
  1399. ]}
  1400.  
  1401.  
  1402. b4_epilogue
  1403. m4_if(b4_defines_flag, 0, [],
  1404. [@output @output_header_name@
  1405. b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
  1406.              [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])
  1407.  
  1408. /* As a special exception, when this file is copied by Bison into a
  1409.    Bison output file, you may use that output file without restriction.
  1410.    This special exception was added by the Free Software Foundation
  1411.    in version 1.24 of Bison.  */
  1412.  
  1413. b4_token_enums_defines(b4_tokens)
  1414.  
  1415. #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
  1416. m4_ifdef([b4_stype],
  1417. [b4_syncline([b4_stype_line], [b4_file_name])
  1418. typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
  1419. /* Line __line__ of yacc.c.  */
  1420. b4_syncline([@oline@], [@ofile@])],
  1421. [typedef int YYSTYPE;])
  1422. # define yystype YYSTYPE /* obsolescent; will be withdrawn */
  1423. # define YYSTYPE_IS_DECLARED 1
  1424. # define YYSTYPE_IS_TRIVIAL 1
  1425. #endif
  1426.  
  1427. b4_pure_if([],
  1428. [extern YYSTYPE b4_prefix[]lval;])
  1429.  
  1430. b4_location_if(
  1431. [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
  1432. typedef struct YYLTYPE
  1433. {
  1434.   int first_line;
  1435.   int first_column;
  1436.   int last_line;
  1437.   int last_column;
  1438. } YYLTYPE;
  1439. # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
  1440. # define YYLTYPE_IS_DECLARED 1
  1441. # define YYLTYPE_IS_TRIVIAL 1
  1442. #endif
  1443.  
  1444. m4_if(b4_pure, [0],
  1445. [extern YYLTYPE b4_prefix[]lloc;])
  1446. ])
  1447. ])
  1448.